Struct core_simd::Simd

#[repr(simd)]
pub struct Simd<T, const LANES: usize>(_)
 where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount;

🔬 This is a nightly-only experimental API. (portable_simd)

A SIMD vector of LANES elements of type T.

Implementations

impl<T> Simd<T, 2> where
    T: SimdElement, 

pub fn shuffle<const IDX: [u32; 2]>(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.

Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.

#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);

pub fn reverse(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Reverse the order of the lanes in the vector.

pub fn interleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);

pub fn deinterleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other lane of self and then other, starting with the first lane.

The second result takes every other lane of self and then other, starting with the second lane.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

impl<T> Simd<T, 4> where
    T: SimdElement, 

pub fn shuffle<const IDX: [u32; 4]>(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.

Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.

#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);

pub fn reverse(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Reverse the order of the lanes in the vector.

pub fn interleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);

pub fn deinterleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other lane of self and then other, starting with the first lane.

The second result takes every other lane of self and then other, starting with the second lane.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

impl<T> Simd<T, 8> where
    T: SimdElement, 

pub fn shuffle<const IDX: [u32; 8]>(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.

Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.

#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);

pub fn reverse(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Reverse the order of the lanes in the vector.

pub fn interleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);

pub fn deinterleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other lane of self and then other, starting with the first lane.

The second result takes every other lane of self and then other, starting with the second lane.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

impl<T> Simd<T, 16> where
    T: SimdElement, 

pub fn shuffle<const IDX: [u32; 16]>(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.

Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.

#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);

pub fn reverse(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Reverse the order of the lanes in the vector.

pub fn interleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);

pub fn deinterleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other lane of self and then other, starting with the first lane.

The second result takes every other lane of self and then other, starting with the second lane.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

impl<T> Simd<T, 32> where
    T: SimdElement, 

pub fn shuffle<const IDX: [u32; 32]>(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.

Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.

#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);

pub fn reverse(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Reverse the order of the lanes in the vector.

pub fn interleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);

pub fn deinterleave(self, other: Self) -> (Self, Self)

🔬 This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other lane of self and then other, starting with the first lane.

The second result takes every other lane of self and then other, starting with the second lane.

This particular permutation is efficient on many architectures.

#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> isize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u8

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u16

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_and(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

pub fn horizontal_or(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

pub fn horizontal_xor(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

pub fn horizontal_max(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> usize

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> f32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal add. Returns the sum of the lanes of the vector.

pub fn horizontal_product(self) -> f32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal multiply. Returns the product of the lanes of the vector.

pub fn horizontal_max(self) -> f32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

pub fn horizontal_min(self) -> f32

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> f64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal add. Returns the sum of the lanes of the vector.

pub fn horizontal_product(self) -> f64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal multiply. Returns the product of the lanes of the vector.

pub fn horizontal_max(self) -> f64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal maximum. Returns the maximum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

pub fn horizontal_min(self) -> f64

🔬 This is a nightly-only experimental API. (portable_simd)

Horizontal minimum. Returns the minimum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

impl<const LANES: usize> Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 1 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 1 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 1 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 2 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 2 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 2 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 4 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 4 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 4 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 8 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 8 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 8 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 8 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 8 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 8 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 1 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 1 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 1 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 2 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 2 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 2 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 4 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 4 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 4 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 8 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 8 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 8 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    LaneCount<{ { 8 * LANES } }>: SupportedLaneCount, 

pub fn to_ne_bytes(self) -> Simd<u8, { { 8 * LANES } }>

🔬 This is a nightly-only experimental API. (portable_simd)

Return the memory representation of this integer as a byte array in native byte order.

pub fn from_ne_bytes(bytes: Simd<u8, { { 8 * LANES } }>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Create a native endian integer value from its memory representation as a byte array in native endianness.

impl<T, const LANES: usize> Simd<T, LANES> where
    T: SimdElement + PartialEq,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn lanes_eq(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is equal to the corresponding lane in other.

pub fn lanes_ne(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is not equal to the corresponding lane in other.

impl<T, const LANES: usize> Simd<T, LANES> where
    T: SimdElement + PartialOrd,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn lanes_lt(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is less than the corresponding lane in other.

pub fn lanes_gt(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is greater than the corresponding lane in other.

pub fn lanes_le(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is less than or equal to the corresponding lane in other.

pub fn lanes_ge(self, other: Self) -> Mask<T::Mask, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Test if each lane is greater than or equal to the corresponding lane in other.

impl<const LANES: usize> Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn ceil(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the smallest integer greater than or equal to each lane.

pub fn floor(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the largest integer value less than or equal to each lane.

pub fn round(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Rounds to the nearest integer value. Ties round toward zero.

pub fn trunc(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the floating point’s integer value, with its fractional part removed.

pub fn fract(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the floating point’s fractional value, with its integer part removed.

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub unsafe fn to_int_unchecked(self) -> Simd<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.

Safety

The value must:

• Not be NaN
• Not be infinite
• Be representable in the return type, after truncating off its fractional part

pub fn round_from_int(value: Simd<i32, LANES>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn ceil(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the smallest integer greater than or equal to each lane.

pub fn floor(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the largest integer value less than or equal to each lane.

pub fn round(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Rounds to the nearest integer value. Ties round toward zero.

pub fn trunc(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the floating point’s integer value, with its fractional part removed.

pub fn fract(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the floating point’s fractional value, with its integer part removed.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub unsafe fn to_int_unchecked(self) -> Simd<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.

Safety

The value must:

• Not be NaN
• Not be infinite
• Be representable in the return type, after truncating off its fractional part

pub fn round_from_int(value: Simd<i64, LANES>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn to_bits(self) -> Simd<u32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Raw transmutation to an unsigned integer vector type with the same size and number of lanes.

pub fn from_bits(bits: Simd<u32, LANES>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Raw transmutation from an unsigned integer vector type with the same size and number of lanes.

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Produces a vector where every lane has the absolute value of the equivalently-indexed lane in self.

pub fn mul_add(self, a: Self, b: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

Using mul_add may be more performant than an unfused multiply-add if the target architecture has a dedicated fma CPU instruction. However, this is not always true, and will be heavily dependent on designing algorithms with specific target hardware in mind.

pub fn sqrt(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Produces a vector where every lane has the square root value of the equivalently-indexed lane in self

pub fn recip(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Takes the reciprocal (inverse) of each lane, 1/x.

pub fn to_degrees(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Converts each lane from radians to degrees.

pub fn to_radians(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Converts each lane from degrees to radians.

pub fn is_sign_positive(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

pub fn is_sign_negative(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

pub fn is_nan(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is NaN.

pub fn is_infinite(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is positive infinity or negative infinity.

pub fn is_finite(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is neither infinite nor NaN.

pub fn is_subnormal(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is subnormal.

pub fn is_normal(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is neither neither zero, infinite, subnormal, or NaN.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Replaces each lane with a number that represents its sign.

• 1.0 if the number is positive, +0.0, or INFINITY
• -1.0 if the number is negative, -0.0, or NEG_INFINITY
• NAN if the number is NAN

pub fn copysign(self, sign: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns each lane with the magnitude of self and the sign of sign.

If any lane is a NAN, then a NAN with the sign of sign is returned.

pub fn min(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the minimum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn max(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the maximum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Restrict each lane to a certain interval unless it is NaN.

For each lane in self, returns the corresponding lane in max if the lane is greater than max, and the corresponding lane in min if the lane is less than min. Otherwise returns the lane in self.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn to_bits(self) -> Simd<u64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Raw transmutation to an unsigned integer vector type with the same size and number of lanes.

pub fn from_bits(bits: Simd<u64, LANES>) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Raw transmutation from an unsigned integer vector type with the same size and number of lanes.

pub fn abs(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Produces a vector where every lane has the absolute value of the equivalently-indexed lane in self.

pub fn mul_add(self, a: Self, b: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

Using mul_add may be more performant than an unfused multiply-add if the target architecture has a dedicated fma CPU instruction. However, this is not always true, and will be heavily dependent on designing algorithms with specific target hardware in mind.

pub fn sqrt(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Produces a vector where every lane has the square root value of the equivalently-indexed lane in self

pub fn recip(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Takes the reciprocal (inverse) of each lane, 1/x.

pub fn to_degrees(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Converts each lane from radians to degrees.

pub fn to_radians(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Converts each lane from degrees to radians.

pub fn is_sign_positive(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

pub fn is_sign_negative(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

pub fn is_nan(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is NaN.

pub fn is_infinite(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is positive infinity or negative infinity.

pub fn is_finite(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is neither infinite nor NaN.

pub fn is_subnormal(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is subnormal.

pub fn is_normal(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each lane if its value is neither neither zero, infinite, subnormal, or NaN.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Replaces each lane with a number that represents its sign.

• 1.0 if the number is positive, +0.0, or INFINITY
• -1.0 if the number is negative, -0.0, or NEG_INFINITY
• NAN if the number is NAN

pub fn copysign(self, sign: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns each lane with the magnitude of self and the sign of sign.

If any lane is a NAN, then a NAN with the sign of sign is returned.

pub fn min(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the minimum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn max(self, other: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns the maximum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Restrict each lane to a certain interval unless it is NaN.

For each lane in self, returns the corresponding lane in max if the lane is greater than max, and the corresponding lane in min if the lane is less than min. Otherwise returns the lane in self.

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<isize, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<isize, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i16, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i16, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i32, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i64, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i8, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i8, LANES>

🔬 This is a nightly-only experimental API. (portable_simd)

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<T, const LANES: usize> Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

pub const fn splat(value: T) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Construct a SIMD vector by setting all lanes to the given value.

pub const fn as_array(&self) -> &[T; LANES]

🔬 This is a nightly-only experimental API. (portable_simd)

Returns an array reference containing the entire SIMD vector.

pub fn as_mut_array(&mut self) -> &mut [T; LANES]

🔬 This is a nightly-only experimental API. (portable_simd)

Returns a mutable array reference containing the entire SIMD vector.

pub const fn from_array(array: [T; LANES]) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

Converts an array to a SIMD vector.

pub const fn to_array(self) -> [T; LANES]

🔬 This is a nightly-only experimental API. (portable_simd)

Converts a SIMD vector to an array.

pub fn gather_or(slice: &[T], idxs: Simd<usize, LANES>, or: Self) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. If an index is out of bounds, that lane instead selects the value from the “or” vector.

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::gather_or(&vec, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));

pub fn gather_or_default(slice: &[T], idxs: Simd<usize, LANES>) -> Self where
    T: Default, 

🔬 This is a nightly-only experimental API. (portable_simd)

SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. Out-of-bounds indices instead use the default value for that lane (0).

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);

let result = Simd::gather_or_default(&vec, idxs); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));

pub fn gather_select(
    slice: &[T],
    mask: Mask<isize, LANES>,
    idxs: Simd<usize, LANES>,
    or: Self
) -> Self

🔬 This is a nightly-only experimental API. (portable_simd)

SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. Out-of-bounds or masked indices instead select the value from the “or” vector.

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let mask = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

let result = Simd::gather_select(&vec, mask, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)

🔬 This is a nightly-only experimental API. (portable_simd)

SIMD scatter: write a SIMD vector’s values into a slice, using potentially discontiguous indices. Out-of-bounds indices are not written. scatter writes “in order”, so if an index receives two writes, only the last is guaranteed.

let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);

vals.scatter(&mut vec, idxs); // index 0 receives two writes.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);

pub fn scatter_select(
    self,
    slice: &mut [T],
    mask: Mask<isize, LANES>,
    idxs: Simd<usize, LANES>
)

🔬 This is a nightly-only experimental API. (portable_simd)

SIMD scatter: write a SIMD vector’s values into a slice, using potentially discontiguous indices. Out-of-bounds or masked indices are not written. scatter_select writes “in order”, so if an index receives two writes, only the last is guaranteed.

let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let mask = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

vals.scatter_select(&mut vec, mask, idxs); // index 0's second write is masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

Trait Implementations

impl<const LANES: usize> Add<&'_ &'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Add<Simd<f32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Add<Simd<f32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Add<Simd<f64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Add<Simd<f64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Add<Simd<i16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Add<Simd<i16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Add<Simd<i32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Add<Simd<i32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Add<Simd<i64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Add<Simd<i64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Add<Simd<i8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Add<Simd<i8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Add<Simd<isize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Add<Simd<isize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Add<Simd<u16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Add<Simd<u16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Add<Simd<u32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Add<Simd<u32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Add<Simd<u64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Add<Simd<u64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Add<Simd<u8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Add<Simd<u8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<Self>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Add<Simd<usize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Add<Simd<usize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Add<Simd<f32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Add<Simd<f64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Add<Simd<i16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Add<Simd<i32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Add<Simd<i64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Add<Simd<i8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Add<Simd<isize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Add<Simd<u16, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Add<Simd<u32, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Add<Simd<u64, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Add<Simd<u8, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Add<Simd<usize, LANES>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Add<f32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Add<f64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Add<i16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Add<i32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Add<i64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Add<i8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Add<isize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Add<u16>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Add<u32>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Add<u64>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Add<u8>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> Add<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Add<usize>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<const LANES: usize> AddAssign<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &f32)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &f64)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &isize)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &u8)

Performs the += operation.

impl<const LANES: usize> AddAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: &usize)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const LANES: usize> AddAssign<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl<const LANES: usize> AddAssign<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl<const LANES: usize> AddAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const LANES: usize> AddAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const LANES: usize> AddAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const LANES: usize> AddAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const LANES: usize> AddAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<const LANES: usize> AddAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const LANES: usize> AddAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const LANES: usize> AddAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const LANES: usize> AddAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const LANES: usize> AddAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn as_mut(&mut self) -> &mut [T; LANES]

Performs the conversion.

impl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn as_ref(&self) -> &[T; LANES]

Performs the conversion.

impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T, const LANES: usize> Binary for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Binary, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitAnd<Simd<i16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitAnd<Simd<i16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitAnd<Simd<i32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitAnd<Simd<i32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitAnd<Simd<i64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitAnd<Simd<i64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitAnd<Simd<i8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitAnd<Simd<i8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitAnd<Simd<isize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitAnd<Simd<isize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitAnd<Simd<u16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitAnd<Simd<u16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitAnd<Simd<u32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitAnd<Simd<u32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitAnd<Simd<u64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitAnd<Simd<u64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitAnd<Simd<u8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitAnd<Simd<u8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<Self>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitAnd<Simd<usize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitAnd<Simd<usize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<i16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<i16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<i32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<i32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<i64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<i64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<i8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<i8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &i8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<isize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<isize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<u16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<u16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<u32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<u32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<u64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<u64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<u8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<u8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &u8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<usize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<usize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitAnd<Simd<i16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitAnd<Simd<i32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitAnd<Simd<i64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitAnd<Simd<i8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitAnd<Simd<isize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitAnd<Simd<u16, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitAnd<Simd<u32, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitAnd<Simd<u64, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitAnd<Simd<u8, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitAnd<Simd<usize, LANES>>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: i16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitAnd<i16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: i16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitAnd<i32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: i64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitAnd<i64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: i64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitAnd<i8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitAnd<isize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitAnd<u16>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitAnd<u32>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitAnd<u64>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitAnd<u8>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAnd<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitAnd<usize>>::Output

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> Self::Output

Performs the & operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &i16)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &i32)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &i64)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &i8)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &isize)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &u16)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &u32)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &u64)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &u8)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: &usize)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: i16)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: i64)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: isize)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: u64)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation.

impl<const LANES: usize> BitAndAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitand_assign(&mut self, rhs: usize)

Performs the &= operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitOr<Simd<i16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitOr<Simd<i16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitOr<Simd<i32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitOr<Simd<i32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitOr<Simd<i64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitOr<Simd<i64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitOr<Simd<i8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitOr<Simd<i8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitOr<Simd<isize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitOr<Simd<isize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitOr<Simd<u16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitOr<Simd<u16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitOr<Simd<u32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitOr<Simd<u32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitOr<Simd<u64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitOr<Simd<u64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitOr<Simd<u8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitOr<Simd<u8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<Self>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitOr<Simd<usize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitOr<Simd<usize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<i16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<i16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<i32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<i32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<i64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<i64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<i8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<i8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &i8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<isize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<isize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<u16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<u16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<u32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<u32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<u64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<u64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<u8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<u8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &u8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<usize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<usize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitOr<Simd<i16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitOr<Simd<i32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitOr<Simd<i64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitOr<Simd<i8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitOr<Simd<isize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitOr<Simd<u16, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitOr<Simd<u32, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitOr<Simd<u64, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitOr<Simd<u8, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitOr<Simd<usize, LANES>>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: i16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitOr<i16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: i16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitOr<i32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: i64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitOr<i64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: i64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitOr<i8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitOr<isize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitOr<u16>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitOr<u32>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitOr<u64>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitOr<u8>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOr<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitOr<usize>>::Output

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> Self::Output

Performs the | operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &i16)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &i32)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &i64)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &i8)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &isize)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &u16)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &u32)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &u64)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &u8)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: &usize)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: i16)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: i64)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: isize)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: u64)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation.

impl<const LANES: usize> BitOrAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitor_assign(&mut self, rhs: usize)

Performs the |= operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitXor<Simd<i16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitXor<Simd<i16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitXor<Simd<i32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitXor<Simd<i32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitXor<Simd<i64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitXor<Simd<i64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitXor<Simd<i8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitXor<Simd<i8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitXor<Simd<isize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitXor<Simd<isize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitXor<Simd<u16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitXor<Simd<u16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitXor<Simd<u32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitXor<Simd<u32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitXor<Simd<u64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitXor<Simd<u64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitXor<Simd<u8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitXor<Simd<u8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<Self>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitXor<Simd<usize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitXor<Simd<usize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<i16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<i16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<i32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<i32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<i64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<i64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<i8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<i8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<isize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<isize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as BitXor<Simd<i16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as BitXor<Simd<i32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as BitXor<Simd<i64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as BitXor<Simd<i8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as BitXor<Simd<isize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as BitXor<Simd<u16, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as BitXor<Simd<u32, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as BitXor<Simd<u64, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as BitXor<Simd<u8, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as BitXor<Simd<usize, LANES>>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as BitXor<i16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as BitXor<i32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as BitXor<i64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as BitXor<i8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as BitXor<isize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXor<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> Self::Output

Performs the ^ operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &i16)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &i32)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &i64)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &i8)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &isize)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &u16)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &u32)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &u64)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &u8)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: &usize)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: i16)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: i64)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: isize)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: u64)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation.

impl<const LANES: usize> BitXorAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn bitxor_assign(&mut self, rhs: usize)

Performs the ^= operation.

impl<T, const LANES: usize> Clone for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, const LANES: usize> Debug for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const LANES: usize> Default for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<const LANES: usize> Div<&'_ &'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Div<Simd<f32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Div<Simd<f32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Div<Simd<f64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Div<Simd<f64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Div<Simd<i16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Div<Simd<i16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Div<Simd<i32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Div<Simd<i32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Div<Simd<i64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Div<Simd<i64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Div<Simd<i8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Div<Simd<i8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Div<Simd<isize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Div<Simd<isize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Div<Simd<u16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Div<Simd<u16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Div<Simd<u32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Div<Simd<u32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Div<Simd<u64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Div<Simd<u64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Div<Simd<u8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Div<Simd<u8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<Self>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Div<Simd<usize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Div<Simd<usize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Div<Simd<f32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Div<Simd<f64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Div<Simd<i16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Div<Simd<i32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Div<Simd<i64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Div<Simd<i8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Div<Simd<isize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Div<Simd<u16, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Div<Simd<u32, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Div<Simd<u64, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Div<Simd<u8, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Div<Simd<usize, LANES>>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Div<f32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Div<f64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Div<i16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Div<i32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Div<i64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Div<i8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Div<isize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Div<u16>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Div<u32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Div<u64>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Div<u8>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> Div<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Div<usize>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<const LANES: usize> DivAssign<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl<const LANES: usize> DivAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const LANES: usize> DivAssign<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const LANES: usize> DivAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const LANES: usize> DivAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<const LANES: usize> DivAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const LANES: usize> DivAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const LANES: usize> DivAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const LANES: usize> DivAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const LANES: usize> DivAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn from(array: [T; LANES]) -> Self

Performs the conversion.

impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn from(vector: Simd<T, LANES>) -> Self

Performs the conversion.

impl From<Simd<f32, 16_usize>> for __m512

fn from(value: f32x16) -> __m512

Performs the conversion.

impl From<Simd<f32, 4_usize>> for __m128

fn from(value: f32x4) -> __m128

Performs the conversion.

impl From<Simd<f32, 8_usize>> for __m256

fn from(value: f32x8) -> __m256

Performs the conversion.

impl From<Simd<f64, 2_usize>> for __m128d

fn from(value: f64x2) -> __m128d

Performs the conversion.

impl From<Simd<f64, 4_usize>> for __m256d

fn from(value: f64x4) -> __m256d

Performs the conversion.

impl From<Simd<f64, 8_usize>> for __m512d

fn from(value: f64x8) -> __m512d

Performs the conversion.

impl From<Simd<i16, 16_usize>> for __m256i

fn from(value: i16x16) -> __m256i

Performs the conversion.

impl From<Simd<i16, 32_usize>> for __m512i

fn from(value: i16x32) -> __m512i

Performs the conversion.

impl From<Simd<i16, 8_usize>> for __m128i

fn from(value: i16x8) -> __m128i

Performs the conversion.

impl From<Simd<i32, 16_usize>> for __m512i

fn from(value: i32x16) -> __m512i

Performs the conversion.

impl From<Simd<i32, 4_usize>> for __m128i

fn from(value: i32x4) -> __m128i

Performs the conversion.

impl From<Simd<i32, 8_usize>> for __m256i

fn from(value: i32x8) -> __m256i

Performs the conversion.

impl From<Simd<i64, 2_usize>> for __m128i

fn from(value: i64x2) -> __m128i

Performs the conversion.

impl From<Simd<i64, 4_usize>> for __m256i

fn from(value: i64x4) -> __m256i

Performs the conversion.

impl From<Simd<i64, 8_usize>> for __m512i

fn from(value: i64x8) -> __m512i

Performs the conversion.

impl From<Simd<i8, 16_usize>> for __m128i

fn from(value: i8x16) -> __m128i

Performs the conversion.

impl From<Simd<i8, 32_usize>> for __m256i

fn from(value: i8x32) -> __m256i

Performs the conversion.

impl From<Simd<isize, 2_usize>> for __m128i

fn from(value: isizex2) -> __m128i

Performs the conversion.

impl From<Simd<isize, 4_usize>> for __m256i

fn from(value: isizex4) -> __m256i

Performs the conversion.

impl From<Simd<isize, 8_usize>> for __m512i

fn from(value: isizex8) -> __m512i

Performs the conversion.

impl From<Simd<u16, 16_usize>> for __m256i

fn from(value: u16x16) -> __m256i

Performs the conversion.

impl From<Simd<u16, 32_usize>> for __m512i

fn from(value: u16x32) -> __m512i

Performs the conversion.

impl From<Simd<u16, 8_usize>> for __m128i

fn from(value: u16x8) -> __m128i

Performs the conversion.

impl From<Simd<u32, 16_usize>> for __m512i

fn from(value: u32x16) -> __m512i

Performs the conversion.

impl From<Simd<u32, 4_usize>> for __m128i

fn from(value: u32x4) -> __m128i

Performs the conversion.

impl From<Simd<u32, 8_usize>> for __m256i

fn from(value: u32x8) -> __m256i

Performs the conversion.

impl From<Simd<u64, 2_usize>> for __m128i

fn from(value: u64x2) -> __m128i

Performs the conversion.

impl From<Simd<u64, 4_usize>> for __m256i

fn from(value: u64x4) -> __m256i

Performs the conversion.

impl From<Simd<u64, 8_usize>> for __m512i

fn from(value: u64x8) -> __m512i

Performs the conversion.

impl From<Simd<u8, 16_usize>> for __m128i

fn from(value: u8x16) -> __m128i

Performs the conversion.

impl From<Simd<u8, 32_usize>> for __m256i

fn from(value: u8x32) -> __m256i

Performs the conversion.

impl From<Simd<usize, 2_usize>> for __m128i

fn from(value: usizex2) -> __m128i

Performs the conversion.

impl From<Simd<usize, 4_usize>> for __m256i

fn from(value: usizex4) -> __m256i

Performs the conversion.

impl From<Simd<usize, 8_usize>> for __m512i

fn from(value: usizex8) -> __m512i

Performs the conversion.

impl<T, const LANES: usize> Hash for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Hash, 

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount,
    I: SliceIndex<[T]>, 

type Output = I::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount,
    I: SliceIndex<[T]>, 

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, const LANES: usize> LowerExp for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + LowerExp, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const LANES: usize> LowerHex for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + LowerHex, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const LANES: usize> Mul<&'_ &'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Mul<Simd<f32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Mul<Simd<f32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Mul<Simd<f64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Mul<Simd<f64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Mul<Simd<i16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Mul<Simd<i16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Mul<Simd<i32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Mul<Simd<i32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Mul<Simd<i64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Mul<Simd<i64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Mul<Simd<i8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Mul<Simd<i8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Mul<Simd<isize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Mul<Simd<isize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Mul<Simd<u16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Mul<Simd<u16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Mul<Simd<u32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Mul<Simd<u32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Mul<Simd<u64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Mul<Simd<u64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Mul<Simd<u8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Mul<Simd<u8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<Self>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Mul<Simd<usize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Mul<Simd<usize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Mul<Simd<f32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Mul<Simd<f64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Mul<Simd<i16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Mul<Simd<i32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Mul<Simd<i64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Mul<Simd<i8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Mul<Simd<isize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Mul<Simd<u16, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Mul<Simd<u32, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Mul<Simd<u64, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Mul<Simd<u8, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Mul<Simd<usize, LANES>>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Mul<f32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Mul<f64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> Mul<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<const LANES: usize> MulAssign<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &f32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl<const LANES: usize> MulAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const LANES: usize> MulAssign<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const LANES: usize> MulAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const LANES: usize> MulAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<const LANES: usize> MulAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const LANES: usize> MulAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const LANES: usize> MulAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const LANES: usize> MulAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const LANES: usize> MulAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<const LANES: usize> Neg for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Neg>::Output

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const LANES: usize> Not for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const LANES: usize> Not for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Not>::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const LANES: usize> Octal for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Octal, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const LANES: usize> Ord for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<const LANES: usize> Rem<&'_ &'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Rem<Simd<f32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Rem<Simd<f32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Rem<Simd<f64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Rem<Simd<f64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Rem<Simd<i16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Rem<Simd<i16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Rem<Simd<i32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Rem<Simd<i32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Rem<Simd<i64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Rem<Simd<i64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Rem<Simd<i8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Rem<Simd<i8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Rem<Simd<isize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Rem<Simd<isize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Rem<Simd<u16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Rem<Simd<u16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Rem<Simd<u32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Rem<Simd<u32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Rem<Simd<u64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Rem<Simd<u64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Rem<Simd<u8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Rem<Simd<u8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<Self>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Rem<Simd<usize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Rem<Simd<usize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<f32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<f32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<f64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<f64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<i16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<i16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<i32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<i32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<i64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<i64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<i8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<i8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<isize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<isize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<u16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<u16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<u32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<u32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<u64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<u64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<u8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<u8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Rem<Simd<f32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Rem<Simd<f64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Rem<Simd<i16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Rem<Simd<i32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Rem<Simd<i64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Rem<Simd<i8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Rem<Simd<isize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Rem<Simd<u16, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Rem<Simd<u32, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Rem<Simd<u64, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Rem<Simd<u8, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Rem<Simd<usize, LANES>>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Rem<f32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Rem<f64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Rem<i16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Rem<i32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Rem<i64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Rem<i8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Rem<isize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Rem<u16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Rem<u32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Rem<u64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Rem<u8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> Rem<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> Self::Output

Performs the % operation.

impl<const LANES: usize> RemAssign<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &f32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &f64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl<const LANES: usize> RemAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<const LANES: usize> RemAssign<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<const LANES: usize> RemAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<const LANES: usize> RemAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<const LANES: usize> RemAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<const LANES: usize> RemAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<const LANES: usize> RemAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<const LANES: usize> RemAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<const LANES: usize> RemAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<T, const LANES: usize> Select<Mask<<T as SimdElement>::Mask, LANES>> for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

fn select(
    mask: Mask<T::Mask, LANES>,
    true_values: Self,
    false_values: Self
) -> Self

impl<const LANES: usize> Shl<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<Self>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<i16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<i16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<i32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<i32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<i64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<i64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<i8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<i8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<isize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<isize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<u16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<u16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<u32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<u32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<u64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<u64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<u8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<u8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<usize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<usize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shl<i16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shl<i32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shl<i64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shl<i8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shl<isize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shl<u16>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shl<u32>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shl<u64>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shl<u8>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> Shl<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shl<usize>>::Output

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<const LANES: usize> ShlAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<Self>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<i16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<i16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<i32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<i32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<i64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<i64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<i8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<i8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<isize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<isize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<u16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<u16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<u32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<u32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<u64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<u64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<u8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<u8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<usize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<usize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Shr<i16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Shr<i32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Shr<i64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Shr<i8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Shr<isize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Shr<u16>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Shr<u32>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Shr<u64>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Shr<u8>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> Shr<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Shr<usize>>::Output

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<const LANES: usize> ShrAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ &'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f32, LANES>> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Sub<Simd<f32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Sub<Simd<f32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<f32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f64, LANES>> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Sub<Simd<f64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Sub<Simd<f64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<f64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i16, LANES>> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Sub<Simd<i16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Sub<Simd<i16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i32, LANES>> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Sub<Simd<i32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Sub<Simd<i32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i64, LANES>> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Sub<Simd<i64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Sub<Simd<i64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i8, LANES>> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Sub<Simd<i8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Sub<Simd<i8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<i8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<isize, LANES>> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Sub<Simd<isize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Sub<Simd<isize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<isize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u16, LANES>> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Sub<Simd<u16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Sub<Simd<u16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u32, LANES>> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Sub<Simd<u32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Sub<Simd<u32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u64, LANES>> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Sub<Simd<u64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Sub<Simd<u64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u8, LANES>> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Sub<Simd<u8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Sub<Simd<u8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<u8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<usize, LANES>> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<Self>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Sub<Simd<usize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Sub<Simd<usize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<usize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<&'_ usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f32, LANES>> for f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f32, LANES>> for &f32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f32 as Sub<Simd<f32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<f32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f64, LANES>> for f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<f64, LANES>> for &f64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <f64 as Sub<Simd<f64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<f64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i16, LANES>> for i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i16, LANES>> for &i16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i16 as Sub<Simd<i16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i32, LANES>> for i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i32, LANES>> for &i32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i32 as Sub<Simd<i32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i64, LANES>> for i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i64, LANES>> for &i64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i64 as Sub<Simd<i64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i8, LANES>> for i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<i8, LANES>> for &i8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <i8 as Sub<Simd<i8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<i8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<isize, LANES>> for isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<isize, LANES>> for &isize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <isize as Sub<Simd<isize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<isize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u16, LANES>> for u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u16, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u16, LANES>> for &u16 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u16 as Sub<Simd<u16, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u16, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u32, LANES>> for u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u32, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u32, LANES>> for &u32 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u32 as Sub<Simd<u32, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u32, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u64, LANES>> for u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u64, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u64, LANES>> for &u64 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u64 as Sub<Simd<u64, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u64, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u8, LANES>> for u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<u8, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<u8, LANES>> for &u8 where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <u8 as Sub<Simd<u8, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<u8, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<usize, LANES>> for usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<usize, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<Simd<usize, LANES>> for &usize where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <usize as Sub<Simd<usize, LANES>>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<usize, LANES>) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<f32> for &Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f32, LANES> as Sub<f32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<f64> for &Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<f64, LANES> as Sub<f64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i16> for &Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i16, LANES> as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i32> for &Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i32, LANES> as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i64> for &Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i64, LANES> as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<i8> for &Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<i8, LANES> as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<isize> for &Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<isize, LANES> as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u16> for &Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u16, LANES> as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u32> for &Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u32, LANES> as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u64> for &Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u64, LANES> as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<u8> for &Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<u8, LANES> as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> Sub<usize> for &Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

type Output = <Simd<usize, LANES> as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<const LANES: usize> SubAssign<&'_ Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &f32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &f64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl<const LANES: usize> SubAssign<&'_ usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const LANES: usize> SubAssign<f32> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<f64> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<i16> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const LANES: usize> SubAssign<i32> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<i64> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<i8> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const LANES: usize> SubAssign<isize> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<const LANES: usize> SubAssign<u16> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const LANES: usize> SubAssign<u32> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const LANES: usize> SubAssign<u64> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const LANES: usize> SubAssign<u8> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const LANES: usize> SubAssign<usize> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<'a, const LANES: usize> Sum<&'a Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, const LANES: usize> Sum<&'a Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<f32, LANES>> for Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<f64, LANES>> for Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<i16, LANES>> for Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<i32, LANES>> for Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<i64, LANES>> for Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<i8, LANES>> for Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<isize, LANES>> for Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<u16, LANES>> for Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<u32, LANES>> for Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<u64, LANES>> for Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<u8, LANES>> for Simd<u8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<const LANES: usize> Sum<Simd<usize, LANES>> for Simd<usize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const LANES: usize> UpperExp for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + UpperExp, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const LANES: usize> UpperHex for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + UpperHex, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const LANES: usize> Copy for Simd<T, LANES> where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

impl<T, const LANES: usize> Eq for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement + Eq,